home *** CD-ROM | disk | FTP | other *** search
/ Precision Software Appli…tions Silver Collection 4 / Precision Software Applications Silver Collection Volume 4 (1993).iso / stats / chadyn.exe / YCROSS.C < prev    next >
Text File  |  1988-12-09  |  9KB  |  323 lines
  1. /******************* (C) 1986,7,8 by JAMES A. YORKE **************************/
  2. /******************************** YCROSS.C ***********************************/
  3. /*************************   Routines in YCROSS.C  ***************************
  4. CRTcrossON(x1,y1,m,n,Color)/ colors m dots on each side of screen point 
  5.         (row,col) and n above and below; /
  6. SetCross(pointnumber) 
  7. CrossPosition()       
  8. turnoff() 
  9.  
  10. ******************************************************************************/
  11.  
  12. #include "yinclud.h"
  13.  
  14. #ifndef X11
  15. #define BLANK 0
  16. #define COLOR color
  17.  
  18. #ifdef DESMET
  19. #define _setcolor(x) null(x)
  20. #endif
  21.  
  22. /* for use with IsCross0Set and IsCross1Set */
  23. static int      CrossVertColor[2][TWICESCRNCROSSHEIGHT];/* [...] = 64 now */
  24. static int      CrossHorzColor[2][TWICESCRNCROSSWIDTH];
  25. extern int      xmax, ymax;        /* set by FindPixel */
  26. #endif    /* X11 */
  27.  
  28. static double    crossX0, crossX1, crossY0, crossY1;
  29.  
  30. #ifndef X11            /* X11 version in YXCROSS.C */
  31. CRTcrossON(x1, y1, m, n, Color)/* colors m dots on each side of screen point
  32.                    (row,col) and n above and below; */
  33. double  x1,
  34.         y1;
  35. int     m,
  36.         n,
  37.         Color;
  38. {
  39.     int     J,
  40.             x,
  41.             y;
  42.  
  43.     _setcolor(Color);
  44.     FindPixel(x1, y1, 1);
  45.  /* this routine puts the coordinates in the vector COL,ROW;  "1" means they
  46.     are for the crt while if == 2 they are for the core copy */
  47.     x = COL;
  48.     y = ROW;
  49.  
  50.  /* HORIZONTAL BAR OF CROSS: */
  51.     if(y > 0 && y < ymax)
  52.         for(J = x - m; J <= x + m; J++)/* left and right */
  53.             if(J != x && J >= 0 && J < xmax) {
  54.                 /* xmax is set by FindPixel */
  55.                 setPixel(J, y, Color);
  56.             /* in MSC, the 3rd variable in setPixel is a dumby and
  57.                changes in the color must be set independently */
  58.             }
  59.  
  60.  /* VERTICAL BAR OF CROSS: */
  61.     if(x > 0 && x < xmax)
  62.         for(J = y - n; J <= y + n; J++)/* above and below */
  63.         /* now pixel x,J */
  64.             if(J >= 0 && J < ymax && J != y) {
  65.                 setPixel(x, J, Color);
  66.             }
  67. }
  68. #endif    /* X11 */
  69.  
  70. #ifndef MAINFRAME
  71. SetCross(crossnumber)        /* when turning on the small cross, it
  72.                    temporarily turns off the big cross, and
  73.                    then turns it back on */
  74.     int     crossnumber;        /* =0 or 1 */
  75. {
  76.     int     should0BeOn;    /* this keeps track of whether cross 0
  77.                    (=BIGCROSS) has been turned off(but should
  78.                    be on) in order to move the little cross; in
  79.                    this case it is YES, otherwise NO */
  80.     int     ss;
  81.  
  82.     if(crossnumber == BIGCROSS) {
  83.         turnoff(BIGCROSS); /* does nothing if already off */
  84.         crossX0 = plotX;/* crossnumber 1 below is very different; why? 
  85.                 */
  86.         crossY0 = plotY;
  87.         cross(crossX0, crossY0, SCRNCROSSWIDTH, SCRNCROSSHEIGHT, SCRN,
  88.             BIGCROSS);
  89.         IsCross0Set = YES;
  90.     }
  91.     if(crossnumber == SMALLCROSS) {
  92.         should0BeOn = IsCross0Set;
  93.         turnoff(BIGCROSS);
  94.         turnoff(SMALLCROSS); /* does nothing if already off */
  95.         ss = ScrnSec;
  96.         crossX1 = y[eqn0 + ssX_coord[ss]];
  97.         crossY1 = y[eqn0 + ssY_coord[ss]];
  98.         cross(crossX1, crossY1, SCRNCROSSWIDTH / 2, SCRNCROSSHEIGHT / 2,
  99.             SCRN, SMALLCROSS);
  100.         IsCross1Set = YES;
  101.         if(crossStatus == ON && printer >= 2)
  102.                 /* if crossStatus is 1, we print position of
  103.                    small cross */
  104.             CrossPosition();
  105.         if(should0BeOn == YES && IsCross0Set == NO)
  106.                 /* turn BIGCROSS back on */
  107.             SetCross(BIGCROSS);
  108.         should0BeOn = NO;
  109.     }
  110.     return;
  111. }
  112. #endif /* ifndef MAINFRAME */
  113.  
  114. CrossPosition() {
  115.     scr_rowcol(2, 28);
  116.     PRINT "   y1 = small cross at x=%g, y=%g  ",
  117.         y[eqn0 + ssX_coord[ScrnSec]], y[eqn0 + ssY_coord[ScrnSec]]);
  118.     scr_rowcol(0, 0);
  119. }
  120.  
  121. #ifndef X11            /* X11 version in YXCROSS.C */
  122. cross(x1, y1, m, n, picnum, crossnum)
  123.                 /* reverses m dots on each side of screen point
  124.                    (row,col) and n above and below; picnum = 1
  125.                    means the screen; = 2 means the core picture
  126.                     */
  127. double  x1,
  128.         y1;
  129. int     m,
  130.         n,
  131.         picnum,
  132.         crossnum;
  133. {
  134.     int     J,
  135.             x,
  136.             y,
  137.             switchColor;
  138.     int    *pixel;
  139.  
  140.     FindPixel(x1, y1, picnum);
  141.  /* this routine puts the coordinates in the vector COL,ROW; if picnum == 1,
  142.     they are for the crt while if == 2 they are for the core copy */
  143.     x = COL;
  144.     y = ROW;
  145.  
  146.     if(picnum == SCRN) {
  147. #ifndef MAINFRAME
  148.     /* switchColor == YES means the cross should be turned off, restoring
  149.        the color that was saved in Cross...[][] */
  150.         if((crossnum == BIGCROSS && IsCross0Set == YES)
  151.                 || (crossnum == SMALLCROSS && IsCross1Set == YES))
  152.             switchColor = YES;
  153.         else
  154.             switchColor = NO;
  155.  
  156.     /* HORIZONTAL BAR OF CROSS: */
  157.         if(y > 0 && y < ymax)
  158.             for(J = x - m; J <= x + m; J++)/* left and right */
  159.                 if(J != x && J >= 0 && J < xmax) {
  160.                 /* xmax is set by FindPixel */
  161.                     pixel = &CrossHorzColor[crossnum][J - (x - m)];
  162.                     if(switchColor == YES) {
  163.                 /* restore pixel J,y */
  164.                         _setcolor(*pixel);
  165.                         setPixel(J, y, *pixel);
  166.                         _setcolor(COLOR);
  167.                     /* in MSC, the 3rd variable in setPixel
  168.                        is a dumby and changes in the color
  169.                        must be set independently */
  170.                     }
  171.                     else {
  172. /* save the current color of the pixel and change it to COLOR, unless it is 
  173. already COLOR in which case it gets blanked */
  174.                         if((*pixel = getPixel (J, y)) != COLOR) {
  175.                             setPixel(J, y, COLOR);
  176.                         }
  177.                         else {
  178.                             _setcolor(BLANK);
  179.                             setPixel(J, y, BLANK);
  180.                             _setcolor(COLOR);
  181.                         }
  182.                     }/* end else */
  183.                 }
  184.     /* VERTICAL BAR OF CROSS: */
  185.         if(x > 0 && x < xmax)
  186.             for(J = y - n; J <= y + n; J++)/* above and below */
  187.             /* now pixel x,J */
  188.                 if(J >= 0 && J < ymax && J != y) {
  189.                     pixel = &CrossVertColor[crossnum][J - (y - n)];
  190.                     if(switchColor == YES) {
  191.                 /* restore pixel x,J */
  192.                         _setcolor(*pixel);
  193.                         setPixel(x, J, *pixel);
  194.                         _setcolor(COLOR);
  195.                     }
  196.                     else {
  197. /* save the current color of the pixel and change it to COLOR, unless it is 
  198. already COLOR in which case it gets blanked */
  199.                         if((*pixel = getPixel (x, J)) != COLOR) {
  200.                             setPixel(x, J, COLOR);
  201.                         }
  202.                         else {
  203.                             _setcolor(BLANK);
  204.                             setPixel(x, J, BLANK);
  205.                             _setcolor(COLOR);
  206.                         }
  207.                     }/* end else */
  208.                 }
  209. #endif /* ifndef MAINFRAME */    
  210.     }
  211.     else 
  212.     {            /* CORE */
  213.         if(y > 0 && y < ymax)
  214.             for(J = x - m; J <= x + m; J++)/* left and right */
  215.                 if(J >= 0 && J < xmax)
  216.                 /* xmax is set by FindPixel */
  217.                     reverseCore(J, y);
  218.  
  219.         if(x > 0 && x < xmax)
  220.             for(J = y - n; J <= y + n; J++)/* above and below */
  221.                 if(J >= 0 && J < ymax)
  222.                     reverseCore(x, J);
  223.     }
  224. }
  225. #endif    /* X11 */
  226.  
  227. #ifndef X11        /* X11 version omits this function */
  228. drawcross(x1, y1, m, n, picnum)/* 
  229.          draws m dots on each side of screen point having coordinates
  230.                  (row,col), and n dots above and below; 
  231.                  picnum 
  232.                  = SCRN = 1 means the screen;
  233.                  = CORE = 2 means the core picture  
  234.                  = HORIZSCRN 3 means horizontal line segment on screen
  235.                  = VERTSCRN  4 means vertical line segment on screen
  236.                  = HORIZCORE 5 means horizontal line segment on core
  237.                  = VERTCORE  6 means vertical line segment on core
  238.                  */
  239. double  x1,
  240.         y1;
  241. int     m,
  242.         n,
  243.         picnum;
  244. {
  245.     int     J,
  246.             x,
  247.             y,
  248.             pick;
  249.     unsigned        row;
  250.  
  251.     if(picnum == SCRN || picnum == HORIZSCRN || picnum == VERTSCRN)
  252.         pick = SCRN;
  253.     else
  254.         pick = CORE;
  255.     FindPixel(x1, y1, pick);
  256.  /* this routine puts the coordinates in the vector COL,ROW; if pick == SCRN,
  257.     they are for the crt while if == CORE they are for the core copy */
  258.     x = COL;
  259.     y = ROW;
  260.  
  261.     if(y > 0 && y < ymax)
  262.         for(J = x - m; J <= x + m; J++)/* left and right */
  263.             if(J >= 0 && J < xmax) {
  264.                 /* xmax is set by FindPixel */
  265. #ifndef MAINFRAME
  266.                 if(picnum == SCRN || picnum == HORIZSCRN)
  267.                     setPixel(J, y, COLOR);
  268.             /* in MSC, the 3rd variable in setPixel is a dumby and
  269.                changes in the color must be set independently */
  270.                 else
  271. #endif /* ifndef MAINFRAME */
  272.                 if(picnum == CORE || picnum == HORIZCORE) {
  273.                     /* first get the relevant byte of
  274.                        pic1[] */
  275.                         rowbit = y % 8;
  276.                         row = y / 8;
  277.  
  278.                     /* change the bit to a 1 */
  279.  
  280.                     /* now put it in pic1[] */
  281.                         corePixel(J * corerows + row, mask[rowbit]);
  282.                     }
  283.             }    /* end if(J >= 0 ... */
  284.     if(x > 0 && x < xmax)
  285.         for(J = y - n; J <= y + n; J++)/* above and below */
  286.             if(J >= 0 && J < ymax) {
  287. #ifndef MAINFRAME
  288.                 if(picnum == SCRN || picnum == VERTSCRN)
  289.                     setPixel(x, J, COLOR);
  290.                 else
  291. #endif /* ifndef MAINFRAME */
  292.                 if(picnum == CORE || picnum == VERTCORE) {
  293.                 /* first get the relevant byte of pic1[] */
  294.                    rowbit = J % 8;
  295.                    row = J / 8;
  296.                    corePixel(x * corerows + row, mask[rowbit]);
  297.                 }
  298.             }    /* end if(J >= 0 ... */
  299. }
  300. #endif    /* X11 */
  301.  
  302. #ifndef X11            /* X11 version in YXCROSS.C */
  303. turnoff(crossnumber)
  304.     int    crossnumber;
  305. {
  306.     if(crossnumber == BIGCROSS)  {
  307.         if(IsCross0Set == YES)
  308.             cross(crossX0, crossY0, SCRNCROSSWIDTH,
  309.                     SCRNCROSSHEIGHT, SCRN, BIGCROSS);
  310.         IsCross0Set = NO;
  311.     } else if(crossnumber == SMALLCROSS)  {
  312.         if(IsCross1Set == YES)
  313.             cross(crossX1, crossY1, SCRNCROSSWIDTH / 2,
  314.                 SCRNCROSSHEIGHT / 2, SCRN, SMALLCROSS);
  315.         IsCross1Set = NO;
  316.     }
  317.     return;
  318. }
  319. #endif    /* X11 */
  320.  
  321.  
  322. /***************************** END of YCROSS.C *******************************/
  323.